﻿//继承(基类和派生类)
 
//限制关系：public < protected < private
//派生类public成员:可以在任何地方使用。
//派生类protected成员:可以在类中使用，不可以在外部使用。
//派生类private成员:可以在类中使用，不可以在外部使用。
//派生类中不可以见:

//class(public)和struct(private)的派生类默认值
//class Student :private Person等价于class Student : Person
//class Student :public Person等价于struct Student : Person
#include <iostream>
#include <string>
using namespace std;

//class Person
//{
//public:
////protected:
////private:
//	void Print()
//	{
//		cout << "name:" <<_name << endl;
//		cout << "age" <<  _age << endl; 
//	}
//protected:
//	string _name = "无名";
//	size_t _age = 0;
//};
//class Student :public Person
//{
//public:
//	void func()
//	{
//		Print();
//	}
//protected:
//	int _stuid = 0;
//};
//class Teacher :public Person
//{
//public:
//	void func()
//	{
//		Print();
//	}
//protected:
//	int _jobid = 0;
//};
//
//int main()
//{
//	Student s;
//	Teacher t;
//	s.Print();
//	t.Print();
//	
//	//会隐式类型转换，生成临时变量。
//	double d = 1.1;
//	const int& i = d;
//	const string& rs = "XXXX";
//
//	//派生类给基类赋值不会隐式类型转换，是天然的。(切割)
//	Person p = s;
//	Person& rp = s;
//	rp.Print();
//
//	return 0;
//}

//////////////////////////////////////////////////////////////////////////
//class Person
//{
//protected:
//	string _name = "大明";
//	size_t _age = 40;
//};
//class Student :public Person
//{
//public:
//	void Print()
//	{
//		cout << "name:" << _name << endl;
//		cout << "age:" << _age << endl;
//	}
//
//protected:
//	string _name = "小明";
//};
//class A
//{
//public:
//	void func()
//	{
//		cout << "fun()" << endl;
//	}
//};
//class B :public A
//{
//public:
//	void func(int)
//	{
//		cout << "func(int)" << endl;
//	}
//};
////父类和子类可以有同名成员。
////子类的同名成员隐藏了（重定义）父类同名成员。
////继承中同名函数构成隐藏。(不是函数重载，因为作用域不同)
//int main()
//{
//	Student s;
//	s.Print();
//	B b;
//	//b.func();
//	b.A::func();
//	b.func(0);
//
//	return 0;
//}

///////////////////////////////////////////////////////////

class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;
		return *this;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};

class Student : public Person
{
public:
	Student(const char* name , int num )
		: Person(name)
		, _num(num)
	{
		cout << "Student()" << endl;
	}
	Student(int num)
		: _num(num)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		: Person(s)
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator =(s);//隐藏
			_num = s._num;
		}
		return *this;
	}
	//由于多态的原因，析构函数统一会被处理成destructor
	//父子类的析构函数会被隐藏
	//为了保证析构安全，先子后父
	//父析构函数不需要显示调用，子类析构函数结束时会自动调用
	//要保证先子后父
	~Student()
	{
		cout << "~Student()" << endl;
	}
protected:
	int _num; //学号
};

int main()
{
	Student s0(16);
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;
	
	return 0;
}